如何在JavaScript中将字符串转换为布尔值？

最新推荐文章于 2024-10-23 09:22:57 发布

asdfgh0077

最新推荐文章于 2024-10-23 09:22:57 发布

阅读量9.3k

点赞数 1

文章标签： javascript

原文链接：https://stackoom.com/question/16fV/如何在JavaScript中将字符串转换为布尔值

版权

我可以将表示布尔值（例如“ true”，“ false”）的字符串转换为JavaScript中的固有类型吗？

我有一个隐藏的HTML表单，该表单会根据用户在列表中的选择进行更新。此表单包含一些表示布尔值的字段，并使用内部布尔值动态填充。但是，一旦将此值放入隐藏的输入字段中，它将成为一个字符串。

一旦将字段转换为字符串，我可以找到确定该字段的布尔值的唯一方法就是依赖其字符串表示形式的文字值。

var myValue = document.myForm.IS_TRUE.value;
var isTrueSet = myValue == 'true';

有没有更好的方法可以做到这一点？

#1楼

就像@ Shadow2531所说，您不能直接将其转换。我还建议您考虑将“ true”和“ false”之外的字符串输入“ true”和“ falsey”，如果您的代码将被其他人重用/使用。这是我用的：

function parseBoolean(string) {
  switch (String(string).toLowerCase()) {
    case "true":
    case "1":
    case "yes":
    case "y":
      return true;
    case "false":
    case "0":
    case "no":
    case "n":
      return false;
    default:
      //you could throw an error, but 'undefined' seems a more logical reply
      return undefined;
  }
}

#2楼

stringToBoolean: function(string){
    switch(string.toLowerCase().trim()){
        case "true": case "yes": case "1": return true;
        case "false": case "no": case "0": case null: return false;
        default: return Boolean(string);
    }
}

#3楼

您正在寻找的表情仅仅是

/^true$/i.test(myValue)

如

var isTrueSet = /^true$/i.test(myValue);

这myValue针对不区分大小写的正则表达式测试myValue ，并且不会修改原型。

例子：

/^true$/i.test("true"); // true
/^true$/i.test("TRUE"); // true
/^true$/i.test("tRuE"); // true
/^true$/i.test(" tRuE"); // false (notice the space at the beginning)
/^true$/i.test("untrue"); // false (some other solutions here will incorrectly return true
/^true$/i.test("false");// returns false
/^true$/i.test("xyz");  // returns false

#4楼

我对这个问题的看法是，它旨在实现三个目标：

对于true和false值，返回true / false，但是对于多个字符串值（如果它们是布尔值而不是字符串），则返回true / false。
其次，提供弹性接口，以使指定值以外的其他值都不会失败，而是返回默认值
第三，用尽可能少的代码来完成所有这些工作。

使用JSON的问题在于，它会由于导致Javascript错误而失败。此解决方案没有弹性（尽管满足1和3）：

JSON.parse("FALSE") // fails

此解决方案不够简洁：

if(value === "TRUE" || value === "yes" || ...) { return true; }

我正在努力解决Typecast.js的确切问题。这三个目标的最佳解决方案是：

return /^true$/i.test(v);

它在很多情况下都有效，当传入{}之类的值时不会失败，并且非常简洁。它还返回false作为默认值，而不是未定义或抛出错误，这在松散类型的Javascript开发中更为有用。勇敢地建议其他答案！

#5楼

我使用以下内容：

function parseBool(b) {
    return !(/^(false|0)$/i).test(b) && !!b;
}

该函数执行通常的布尔强制，除了字符串“ false”（不区分大小写）和“ 0”以外。

#6楼

我有点晚了，但我有一个小片段来做到这一点，它本质上维护所有JScripts truthey / falsey / 肮脏 -ness的，但包括"false"为假的acceptible值。

我不喜欢这种方法，因为它不依赖第三方来解析代码（例如：eval / JSON.parse），这在我看来是过大了，它足够短，不需要实用程序函数并进行维护其他的Trueey / Falsey约定。

var value = "false";
var result = (value == "false") != Boolean(value);

// value = "true"  => result = true
// value = "false" => result = false
// value = true    => result = true
// value = false   => result = false
// value = null    => result = false
// value = []      => result = true
// etc..

#7楼

function parseBool(value) {
    if (typeof value === "boolean") return value;

    if (typeof value === "number") {
        return value === 1 ? true : value === 0 ? false : undefined;
    }

    if (typeof value != "string") return undefined;

    return value.toLowerCase() === 'true' ? true : false;
}

#8楼

我写了一个函数来匹配PHP的filter_var，它很好地做到了这一点。要点可用： https : //gist.github.com/CMCDragonkai/7389368

/**
 * Parses mixed type values into booleans. This is the same function as filter_var in PHP using boolean validation
 * @param  {Mixed}        value 
 * @param  {Boolean}      nullOnFailure = false
 * @return {Boolean|Null}
 */
var parseBooleanStyle = function(value, nullOnFailure = false){
    switch(value){
        case true:
        case 'true':
        case 1:
        case '1':
        case 'on':
        case 'yes':
            value = true;
            break;
        case false:
        case 'false':
        case 0:
        case '0':
        case 'off':
        case 'no':
            value = false;
            break;
        default:
            if(nullOnFailure){
                value = null;
            }else{
                value = false;
            }
            break;
    }
    return value;
};

#9楼

Boolean.parse = function (str) {
  switch (str.toLowerCase ()) {
    case "true":
      return true;
    case "false":
      return false;
    default:
      throw new Error ("Boolean.parse: Cannot convert string to boolean.");
  }
};

#10楼

带有JSON解析的通用解决方案：

function getBool(val) {
    return !!JSON.parse(String(val).toLowerCase());
}

getBool("1"); //true
getBool("0"); //false
getBool("true"); //true
getBool("false"); //false
getBool("TRUE"); //true
getBool("FALSE"); //false

UPDATE（不带JSON）：

function getBool(val){ 
    var num = +val;
    return !isNaN(num) ? !!num : !!String(val).toLowerCase().replace(!!0,'');
}

我还创建了小提琴来对其进行测试http://jsfiddle.net/remunda/2GRhG/

#11楼

我以为@Steven的答案是最好的答案，并且比传入值只是一个字符串要多得多。我想对其进行扩展并提供以下内容：

function isTrue(value){
    if (typeof(value) === 'string'){
        value = value.trim().toLowerCase();
    }
    switch(value){
        case true:
        case "true":
        case 1:
        case "1":
        case "on":
        case "yes":
            return true;
        default: 
            return false;
    }
}

如果您已经知道所有true情况，就不必涵盖所有false情况。您可以将任何可以传递为true值的方法传递给此方法（或添加其他值，这非常简单），其他所有内容都将被视为false

#12楼

木眼要小心。在对500多个投票应用了最高答案后，看到了后果，我觉得有义务发布一些实际上有用的东西：

让我们从最短但非常严格的方式开始：

var str = "true";
var mybool = JSON.parse(str);

并以正确，更宽容的方式结束：

var parseBool = function(str) 
{
    // console.log(typeof str);
    // strict: JSON.parse(str)

    if(str == null)
        return false;

    if (typeof str === 'boolean')
    {
        return (str === true);
    } 

    if(typeof str === 'string')
    {
        if(str == "")
            return false;

        str = str.replace(/^\s+|\s+$/g, '');
        if(str.toLowerCase() == 'true' || str.toLowerCase() == 'yes')
            return true;

        str = str.replace(/,/g, '.');
        str = str.replace(/^\s*\-\s*/g, '-');
    }

    // var isNum = string.match(/^[0-9]+$/) != null;
    // var isNum = /^\d+$/.test(str);
    if(!isNaN(str))
        return (parseFloat(str) != 0);

    return false;
}

测试：

var array_1 = new Array(true, 1, "1",-1, "-1", " - 1", "true", "TrUe", "  true  ", "  TrUe", 1/0, "1.5", "1,5", 1.5, 5, -3, -0.1, 0.1, " - 0.1", Infinity, "Infinity", -Infinity, "-Infinity"," - Infinity", " yEs");

var array_2 = new Array(null, "", false, "false", "   false   ", " f alse", "FaLsE", 0, "00", "1/0", 0.0, "0.0", "0,0", "100a", "1 00", " 0 ", 0.0, "0.0", -0.0, "-0.0", " -1a ", "abc");


for(var i =0; i < array_1.length;++i){ console.log("array_1["+i+"] ("+array_1[i]+"): " + parseBool(array_1[i]));}

for(var i =0; i < array_2.length;++i){ console.log("array_2["+i+"] ("+array_2[i]+"): " + parseBool(array_2[i]));}

for(var i =0; i < array_1.length;++i){ console.log(parseBool(array_1[i]));}
for(var i =0; i < array_2.length;++i){ console.log(parseBool(array_2[i]));}

#13楼

var falsy = /^(?:f(?:alse)?|no?|0+)$/i;
Boolean.parse = function(val) { 
    return !falsy.test(val) && !!val;
};

这将返回false每falsy值与true对于不同的是每truthy值'false' ， 'f' ， 'no' ， 'n' ，和'0' （不区分大小写）。

// False
Boolean.parse(false);
Boolean.parse('false');
Boolean.parse('False');
Boolean.parse('FALSE');
Boolean.parse('f');
Boolean.parse('F');
Boolean.parse('no');
Boolean.parse('No');
Boolean.parse('NO');
Boolean.parse('n');
Boolean.parse('N');
Boolean.parse('0');
Boolean.parse('');
Boolean.parse(0);
Boolean.parse(null);
Boolean.parse(undefined);
Boolean.parse(NaN);
Boolean.parse();

//True
Boolean.parse(true);
Boolean.parse('true');
Boolean.parse('True');
Boolean.parse('t');
Boolean.parse('yes');
Boolean.parse('YES');
Boolean.parse('y');
Boolean.parse('1');
Boolean.parse('foo');
Boolean.parse({});
Boolean.parse(1);
Boolean.parse(-1);
Boolean.parse(new Date());

#14楼

做：

var isTrueSet = (myValue == 'true');

您可以通过使用标识运算符（ === ）来使其更严格，当比较的变量具有不同类型时，它不会进行任何隐式类型转换，而不是等于运算符（ == ）。

var isTrueSet = (myValue === 'true');

别：

您可能应谨慎使用这两种方法来满足您的特定需求：

var myBool = Boolean("false");  // == true

var myBool = !!"false";  // == true

任何不是空字符串的字符串都将通过使用它们来评估为true 。尽管它们是我可以想到的与布尔转换有关的最干净的方法，但我认为它们并不是您想要的。

#15楼

记住要区分大小写：

var isTrueSet = (myValue.toLowerCase() === 'true');

另外，如果它是一个表单元素复选框，则还可以检测是否已选中该复选框：

var isTrueSet = document.myForm.IS_TRUE.checked;

假设如果选中，则将其“设置”为true。评估为真/假。

#16楼

您的解决方案很好。

在这种情况下，使用===会很愚蠢，因为该字段的value始终是String 。

#17楼

您需要（在您的思想中）分离选择的价值和该价值的表示形式。

在JavaScript逻辑中选择一个点，他们需要将其从字符串标记转换为原始类型，并在那里进行比较，最好是在每个需要转换的值仅完成一次的情况下进行比较。记住要解决如果字符串sendinel不是脚本知道的字符串（例如，您默认为true还是false）的情况，该怎么办？

换句话说，是的，您需要依赖于字符串的值。 :-)

#18楼

您可以使用正则表达式：

/*
 * Converts a string to a bool.
 *
 * This conversion will:
 *
 *  - match 'true', 'on', or '1' as true.
 *  - ignore all white-space padding
 *  - ignore capitalization (case).
 *
 * '  tRue  ','ON', and '1   ' will all evaluate as true.
 *
 */
function strToBool(s)
{
    // will match one and only one of the string 'true','1', or 'on' rerardless
    // of capitalization and regardless off surrounding white-space.
    //
    regex=/^\s*(true|1|on)\s*$/i

    return regex.test(s);
}

如果您想扩展String类，则可以执行以下操作：

String.prototype.bool = function() {
    return strToBool(this);
};

alert("true".bool());

对于那些想要扩展String对象来实现此目的（但请注意注释）的人，他们担心可枚举性，并担心与其他扩展String对象的代码发生冲突：

Object.defineProperty(String.prototype, "com_example_bool", {
    get : function() {
        return (/^(true|1)$/i).test(this);
    }
});
alert("true".com_example_bool);

（当然，在旧版浏览器中将无法使用，而Firefox显示为false，而Opera，Chrome，Safari和IE显示为true。错误720760 ）

#19楼

我正在用这个

String.prototype.maybeBool = function(){

    if ( ["yes", "true", "1", "on"].indexOf( this.toLowerCase() ) !== -1 ) return true;
    if ( ["no", "false", "0", "off"].indexOf( this.toLowerCase() ) !== -1 ) return false;

    return this;

}

"on".maybeBool(); //returns true;
"off".maybeBool(); //returns false;
"I like js".maybeBool(); //returns "I like js"

#20楼

答案很多，很难选择。就我而言，我在选择时会优先考虑性能，因此我创建了这个jsPerf ，希望可以对此有所启发。

结果简介（越高越好）：

它们链接到相关的答案，您可以在其中找到有关每个答案的更多信息（利弊）；特别是在评论中。

#21楼

要将string（“ true”，“ false”）和boolean都转换为boolean

('' + flag) === "true"

flag可以在哪里

 var flag = true
 var flag = "true"
 var flag = false
 var flag = "false"

#22楼

另一个解决方案。 jsFiddle

var toBoolean = function(value) {
    var strValue = String(value).toLowerCase();
    strValue = ((!isNaN(strValue) && strValue !== '0') &&
        strValue !== '' &&
        strValue !== 'null' &&
        strValue !== 'undefined') ? '1' : strValue;
    return strValue === 'true' || strValue === '1' ? true : false
};

测试用例在节点中运行

> toBoolean(true)
true
> toBoolean(false)
false
> toBoolean(undefined)
false
> toBoolean(null)
false
> toBoolean('true')
true
> toBoolean('True')
true
> toBoolean('False')
false
> toBoolean('false')
false
> toBoolean('0')
false
> toBoolean('1')
true
> toBoolean('100')
true
>

#23楼

我认为这很普遍：

if (String(a) == "true") ...

它去了：

String(true) == "true"     //returns true
String(false) == "true"    //returns false
String("true") == "true"   //returns true
String("false") == "true"  //returns false

#24楼

已经有很多答案。但是在某些情况下，遵循可能会很有用。

// One can specify all values against which you consider truthy
var TRUTHY_VALUES = [true, 'true', 1];

function getBoolean(a) {
    return TRUTHY_VALUES.some(function(t) {
        return t === a;
    });
}

在一个带有非布尔值的示例中，这可能很有用。

getBoolean('aa'); // false
getBoolean(false); //false
getBoolean('false'); //false

getBoolean('true'); // true
getBoolean(true); // true
getBoolean(1); // true

#25楼

这是从公认的答案中得出的，但实际上它有一个很薄弱的地方，我很震惊它如何获得赞成票数，它的问题在于您必须考虑字符串的大小写，因为这是区分大小写的

var isTrueSet = (myValue.toLowerCase() === 'true');

#26楼

布尔对象没有'parse'方法。 Boolean('false')返回true，因此将不起作用。 !!'false'也返回true ，因此也将不起作用。

如果您希望字符串'true'返回布尔值true而字符串'false'返回布尔值false ，则最简单的解决方案是使用eval() 。 eval('true')返回true，而eval('false')返回false。不过请记住，在使用eval()时eval()性能产生影响。

#27楼

你为什么不尝试这样的事情

Boolean(JSON.parse((yourString.toString()).toLowerCase()));

当给出其他一些文本而不是true或false时，无论大小写如何，它将返回错误，并且还将捕获数字

// 0-> false
// any other number -> true

#28楼

此函数可以处理字符串以及布尔值true / false。

function stringToBoolean(val){
    var a = {
        'true':true,
        'false':false
    };
    return a[val];
}

演示如下：

 function stringToBoolean(val) { var a = { 'true': true, 'false': false }; return a[val]; } console.log(stringToBoolean("true")); console.log(typeof(stringToBoolean("true"))); console.log(stringToBoolean("false")); console.log(typeof(stringToBoolean("false"))); console.log(stringToBoolean(true)); console.log(typeof(stringToBoolean(true))); console.log(stringToBoolean(false)); console.log(typeof(stringToBoolean(false))); console.log("============================================="); // what if value was undefined? console.log("undefined result: " + stringToBoolean(undefined)); console.log("type of undefined result: " + typeof(stringToBoolean(undefined))); console.log("============================================="); // what if value was an unrelated string? console.log("unrelated string result: " + stringToBoolean("hello world")); console.log("type of unrelated string result: " + typeof(stringToBoolean(undefined)));

#29楼

放下最简单的方法（假设您的字符串为“ true”或“ false”）是：

var z = 'true';
var y = 'false';
var b = (z === 'true'); // will evaluate to true
var c = (y === 'true'); // will evaluate to false

对于这些类型的转换，请始终使用===运算符而不是==运算符！

#30楼

警告

从技术上讲，这个高度推崇的旧式答案是正确的，但是仅当字符串值完全为"true"或"false"时，才涵盖非常特定的情况。

在下面的函数中传递的无效json字符串将引发异常 。

原始答案：

怎么样？

JSON.parse("True".toLowerCase());

或与jQuery

$.parseJSON("TRUE".toLowerCase());

asdfgh0077

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
3
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫